home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / jovept1.arc / BUF.C < prev    next >
Text File  |  1985-05-30  |  9KB  |  507 lines
  1. /* buf.c */
  2.  
  3. /* JOVE/MSDOS. K. Mitchum 1/85 */
  4. /* Modifications for personal use only. */
  5. /* original code J. Payne LSRHS 5/83 */
  6. /* Ken Mitchum */
  7. /* University of Pittsburgh */
  8. /* Decision Systems Laboratory */
  9.  
  10. /* Jonathan Payne at Lincoln-Sudbury Regional High School 5-25-83
  11.  
  12.    jove_buf.c
  13.    
  14.    Contains commands that deal with creating, selecting, killing and
  15.    listing buffers.  (And find-file) */
  16.    
  17.  
  18. #include "jove.h"
  19.  
  20. #ifdef UNIX
  21. #include <sys/types.h>
  22. #include <sys/stat.h>
  23. #else
  24. #include "stat.h"
  25. #endif
  26.  
  27. extern int
  28.     OverWrite(),
  29.     TextInsert(),
  30.     SelfInsert(),
  31.     DoParen(),
  32.     DoBrace(),
  33.     CTab(),
  34.     LineAI(),
  35.     Newline();
  36.  
  37. extern int origflags[];    /* main.c */
  38. extern char *Mainbuf;    /* main.c */
  39. extern BUFFER *world;    /* main.c */
  40. extern int UseBuffers;    /* funcs.h */
  41. extern int UpdModLine;    /* disp.c */
  42.  
  43. static int flen,
  44.     blen;
  45. static BUFFER    *lastbuf = 0;
  46.  
  47.  
  48. char *
  49. filename(bp)
  50. BUFFER    *bp;
  51. {
  52.     return bp->b_fname ? bp->b_fname : "[No file]";
  53. }
  54.  
  55. char *
  56. itoa(num)
  57. {
  58.     static char    line[10];
  59.  
  60.     return sprintf(line,"%d", num);
  61. }
  62.  
  63. AllInts(str)
  64. register char    *str;
  65. {
  66.     register char    c;
  67.  
  68.     while ((c = *str++) >= '0' && c <= '9')
  69.         ;
  70.     return c == 0;
  71. }
  72.  
  73. BUFFER *
  74. buf_exists(name)
  75. char    *name;
  76. {
  77.     BUFFER    *bp;
  78.     int    n;
  79.  
  80.     if (name)
  81.         for (bp = world; bp; bp = bp->b_next)
  82. #ifdef UNIX
  83.             if (bp->b_zero && strcmp(bp->b_name, name) == 0)
  84. #else
  85.             if (bp->b_zero && ustrcmp(bp->b_name, name) == 0)
  86. #endif
  87.                 return bp;
  88.  
  89.     /* Doesn't match any names.  Try for a buffer number */
  90.  
  91.     if (AllInts(name) && (n = atoi(name)) > 0) {
  92.         for (bp = world; n - 1 > 0; ) {
  93.             if (bp == 0)
  94.                 break;
  95.             if (bp->b_zero == 0)
  96.                 continue;
  97.             bp = bp->b_next;
  98.             --n;
  99.         }
  100.         return bp;
  101.     }
  102.  
  103.     return 0;
  104. }
  105.  
  106. BUFFER *
  107. file_exists(fname)
  108. char    *fname;
  109. {
  110.     struct stat    stbuf;
  111.     BUFFER    *bp;
  112.  
  113.     if (fname) {
  114.         if (stat(fname, &stbuf) == -1)
  115.             stbuf.st_ino = -1;
  116.         for (bp = world; bp; bp = bp->b_next) {
  117.             if (bp->b_zero == 0)
  118.                 continue;
  119.             if ((bp->b_ino != -1) && (bp->b_ino == stbuf.st_ino))
  120.                 return bp;
  121. #ifdef UNIX
  122.             if (strcmp(bp->b_fname, fname) == 0)
  123. #else
  124.             if (ustrcmp(bp->b_fname, fname) == 0)
  125. #endif
  126.                 return bp;
  127.         }
  128.     }
  129.     return 0;
  130. }
  131.  
  132. max(a, b)
  133. int a, b;
  134. {
  135.     return a > b ? a : b;
  136. }
  137.  
  138. BUFFER *
  139. findbuf()
  140. {
  141.     BUFFER    *bp,
  142.         *lastbp;
  143.  
  144.     lastbp = 0;
  145.     for (bp = world; bp; lastbp = bp, bp = bp->b_next)
  146.         if (bp->b_zero == 0)
  147.             break;
  148.     if (bp == 0) {
  149.         bp = (BUFFER *) emalloc(sizeof (BUFFER));
  150.         if (lastbp)
  151.             lastbp->b_next = bp;
  152.         else
  153.             world = bp;
  154.         bp->b_zero = 0;
  155.         bp->b_next = 0;
  156.     }
  157.     return bp;
  158. }
  159.  
  160. setfuncs(flags)
  161. int    *flags;
  162. {
  163.     UpdModLine++;    /* Kludge ... but speeds things up considerably */
  164.     copy_n(curbuf->b_flags, flags, NFLAGS);
  165.  
  166.     if (IsFlagSet(flags, OVERWRITE))
  167.         BindInserts(OverWrite);
  168.     else if (IsFlagSet(flags, TEXTFILL))
  169.         BindInserts(TextInsert);
  170.     else
  171.         BindInserts(SelfInsert);
  172.     if (IsFlagSet(flags, CMODE) || IsFlagSet(flags, MATCHING)) {
  173.         BindFunc(mainmap, '}', DoParen);
  174.         BindFunc(mainmap, ')', DoParen);
  175.         BindFunc(mainmap, '{', DoBrace);
  176.     } else {
  177.         BindFunc(mainmap, '}', SelfInsert);
  178.         BindFunc(mainmap, ')', SelfInsert);
  179.         BindFunc(mainmap, '{', SelfInsert);
  180.     }
  181.     if (IsFlagSet(flags, CMODE))
  182.         BindFunc(mainmap, CTL(I), CTab);
  183.     else
  184.         BindFunc(mainmap, CTL(I), SelfInsert);
  185.     if (IsFlagSet(flags, AUTOIND))
  186.         BindFunc(mainmap, CTL(M), LineAI);
  187.     else
  188.         BindFunc(mainmap, CTL(M), Newline);
  189. }
  190.  
  191. noflags(f)
  192. register int    *f;
  193. {
  194.     register int    i = NFLAGS;
  195.  
  196.     while (i--)
  197.         *f++ = 0;
  198. }
  199.  
  200. setflags(buf)
  201. BUFFER    *buf;
  202. {
  203.     copy_n(buf->b_flags, origflags, NFLAGS);
  204.     SetUnmodified(buf);
  205.     buf->b_type = NORMALBUF;    /* Normal until proven SCRATCHBUF */
  206. }
  207.  
  208. BUFFER *
  209. mak_buf(fname, bname)
  210. char    *fname,
  211.     *bname;
  212. {
  213.     register BUFFER    *freebuf;
  214.     register int    i;
  215.  
  216.     freebuf = buf_exists(bname);
  217.     if (!freebuf) {
  218.         freebuf = findbuf();
  219.         freebuf->b_fname = freebuf->b_name = 0;
  220.         setbname(freebuf, bname);
  221.         setfname(freebuf, fname);
  222.         set_ino(freebuf);
  223.         freebuf->b_marks = 0;
  224.         freebuf->b_themark = 0;        /* Index into markring */
  225.         for (i = 0; i < NMARKS; i++)
  226.             freebuf->b_markring[i] = 0;
  227.         /* No marks yet */
  228.         setflags(freebuf);
  229.         freebuf->b_zero = 0;
  230.         initlist(freebuf);
  231.     }
  232.     return freebuf;
  233. }
  234.  
  235. char *
  236. ralloc(obj, size)
  237. char    *obj;
  238. {
  239.     char    *new;
  240.     if (obj)
  241.         new = realloc(obj, (unsigned) size);
  242.     if (new == 0 || !obj)
  243.         new = emalloc(size);
  244.     if (new == 0)
  245.         error("No memory in ralloc");
  246.     return new;
  247. }
  248.  
  249. setbname(bp, name)
  250. BUFFER    *bp;
  251. char    *name;
  252. {
  253.     UpdModLine++;    /* Kludge ... but speeds things up considerably */
  254.     if (name) {
  255.         bp->b_name = ralloc(bp->b_name, strlen(name) + 1);
  256.         strcpy(bp->b_name, name);
  257.     } else
  258.         bp->b_name = 0;
  259. }
  260.  
  261. setfname(bp, name)
  262. BUFFER    *bp;
  263. char    *name;
  264. {
  265.     UpdModLine++;    /* Kludge ... but speeds things up considerably */
  266.     if (name) {
  267.         bp->b_fname = ralloc(bp->b_fname, strlen(name) + 1);
  268.         strcpy(bp->b_fname, name);
  269.     } else
  270.         bp->b_fname = 0;
  271. }
  272.  
  273. set_ino(bp)
  274. BUFFER    *bp;
  275. {
  276.     struct stat    stbuf;
  277.  
  278.     if (bp->b_fname && stat(bp->b_fname, &stbuf) == -1)
  279.         bp->b_ino = -1;
  280.     else
  281.         bp->b_ino = stbuf.st_ino;
  282. }
  283.  
  284. /* Find the file `fname' into buf and put in in window `wp' */
  285.  
  286. BUFFER *
  287. do_find(wp, fname)
  288. WINDOW    *wp;
  289. char    *fname;
  290. {
  291.     BUFFER    *oldb = curbuf,
  292.         *bp;
  293.  
  294.     oldb = curbuf;
  295.     bp = file_exists(fname);
  296.     if (bp == 0) {
  297.         bp = mak_buf(fname, (char *) 0);
  298.         bufname(bp);
  299.         SetBuf(bp);
  300.         read_file(bp->b_fname);
  301.         SetBuf(oldb);
  302.     }
  303.     if (wp)
  304.         tiewind(wp, bp);
  305.     return bp;
  306. }
  307.  
  308. tiewind(wp, bp)
  309. WINDOW    *wp;
  310. BUFFER    *bp;
  311. {
  312.     wp->w_line = bp->b_dot;
  313.     wp->w_char = bp->b_char;
  314.     if (wp->w_bufp != bp) {
  315.         wp->w_bufp = bp;
  316.         CalcTop(wp);
  317.     }
  318. }
  319.  
  320. FindFile()
  321. {
  322.     char    *name;
  323.  
  324.     name = ask(curbuf->b_fname, FuncName());
  325.     lastbuf = curbuf;
  326.     SetBuf(do_find(curwind, name));
  327. }
  328.  
  329. VisitFile()
  330. {
  331.     char    *name;
  332.  
  333.     name = ask(curbuf->b_fname, FuncName());
  334.     SplitWind();
  335.     lastbuf = curbuf;
  336.     SetBuf(do_find(curwind, name));
  337. }
  338.  
  339.  
  340. SetBuf(newbuf)
  341. BUFFER    *newbuf;
  342. {
  343.     if (newbuf == curbuf)
  344.         return;
  345.     lastbuf = curbuf;
  346.     copy_n(curbuf->b_flags, globflags, NFLAGS);
  347.     lsave();
  348.     curbuf = newbuf;
  349.     getDOT();
  350.     copy_n(globflags, curbuf->b_flags, NFLAGS);
  351.     setfuncs(curbuf->b_flags);
  352. }    
  353.  
  354. SelBuf()
  355. {
  356.     char    *bname;
  357.  
  358.     bname = ask(lastbuf ? lastbuf->b_name : (char *) 0, FuncName());
  359.     lastbuf = curbuf;
  360.     SetBuf(do_select(curwind, bname));
  361. }
  362.  
  363. BUFFER *
  364. do_select(wp, name)
  365. WINDOW    *wp;
  366. char    *name;
  367. {
  368.     BUFFER    *new;
  369.  
  370.     new = mak_buf((char *) 0, name);
  371.     if (wp)
  372.         tiewind(wp, new);
  373.     return new;
  374. }
  375.  
  376. defb_wind(bp)
  377. BUFFER *bp;
  378. {
  379.     WINDOW    *wp = fwind;
  380.  
  381.     do {
  382.         if (wp->w_bufp == bp) {
  383.             if (bp == curbuf)
  384.                 ignore(do_select(wp, Mainbuf));
  385.             else {
  386.                 WINDOW    *save = wp->w_next;
  387.  
  388.                 del_wind(wp);
  389.                 wp = save->w_prev;
  390.             }
  391.         }                
  392.         wp = wp->w_next;
  393.     } while (wp != fwind);
  394. }
  395.  
  396. BUFFER *
  397. AskBuf(prompt)
  398. char    *prompt;
  399. {
  400.     BUFFER    *delbuf;
  401.     char    *bname;
  402.  
  403.     bname = ask(curbuf->b_name, prompt);
  404.     if (strcmp(bname, Mainbuf) == 0)
  405.         return 0;
  406.     delbuf = buf_exists(bname);
  407.     if (delbuf == 0)
  408.         complain("%s: no such buffer", bname);
  409.     if (delbuf->b_modified)
  410.         confirm("%s modified, are you sure? ", bname);
  411.     return delbuf;
  412. }
  413.  
  414. BufErase()
  415. {
  416.     BUFFER    *delbuf;
  417.  
  418.     if (delbuf = AskBuf(FuncName()))
  419.         initlist(delbuf);
  420.     SetUnmodified(delbuf);
  421. }
  422.  
  423. BufKill()
  424. {
  425.     BUFFER    *delbuf;
  426.  
  427.     if ((delbuf = AskBuf(FuncName())) == 0)
  428.         return;
  429.     defb_wind(delbuf);
  430.     if (curbuf == delbuf)
  431.         SetBuf(curwind->w_bufp);
  432.     lfreelist(delbuf->b_zero);
  433.     delbuf->b_zero = 0;
  434.     if (delbuf == lastbuf)
  435.         lastbuf = curbuf;
  436. }
  437.  
  438. BufList()
  439. {
  440.     char    format[40];
  441.     int    bcount = 1;        /* To give each buffer a number */
  442.     BUFFER    *bp;
  443.     int    what;
  444.  
  445.     b_format(format);
  446.  
  447.     if (UseBuffers) {
  448.         TellWBuffers("Buffer list", 0);
  449.         curwind->w_bufp->b_type = SCRATCHBUF;
  450.     } else
  451.         TellWScreen(0);
  452.  
  453.     ignore(DoTell(sprint(format, "NO", "Buffer-type", "File-name", "Buffer-name", "")));
  454.     ignore(DoTell(sprint(format, "--", "-----------", "---------", "-----------", "")));
  455.     for (bp = world; bp; bp = bp->b_next) {
  456.         if (bp->b_zero == 0)
  457.             continue;
  458.         what = DoTell(sprint(format, itoa(bcount++),
  459.                     bp->b_type == SCRATCHBUF ?
  460.                         "SCRATCH" : "FILE",
  461.                     filename(bp),
  462.                     bp->b_name,
  463.                     bufmod(bp)));
  464.         if (what == ABORT || what == STOP)
  465.             break;
  466.     }
  467.     if (UseBuffers) {
  468.         Bof();        /* Go to the beginning of the file */
  469.         NotModified();
  470.     }
  471.     StopTelling();
  472. }
  473.  
  474. b_format(fmt)
  475. char    *fmt;
  476. {
  477.     BUFFER    *bp;
  478.  
  479.     flen = 9;
  480.     blen = 11;
  481.  
  482.     for (bp = world; bp; bp = bp->b_next) {
  483.         flen = max(flen, (bp->b_fname ? strlen(bp->b_fname) : 0));
  484.         blen = max(blen, strlen(bp->b_name));
  485.     }
  486.     ignore(sprintf(fmt, " %%-4s %%-11s  %%-%ds   %%-%ds  %%s", flen, blen));
  487. }
  488.  
  489. #ifndef UNIX
  490. ustrcmp(s,t)    /* simple strcmp no case. returns 0 */
  491. char *s,*t;        /* if strings match, case independent */
  492. {                /* does not return string order */
  493.     char c,d;
  494.     while(*s && *t && ((*s == *t) ||
  495.        (((c = (*s | 0x20)) >= 'a' && c <= 'z') &&
  496.       ((d = (*t | 0x20)) >= 'a' && d <= 'z') && (c == d)))) {
  497.         s++;
  498.         t++;
  499.     }
  500.     if(*s || *t) return(-1);
  501.     return(0);
  502. }
  503. #endif
  504.  
  505.  
  506. /* end */
  507.